1. Field of the Invention
This invention is related to the fields of computing machines; parallel processing; parallel computing; multiple thread program execution; the computer language Cobol; the computer languages JAVA, C/C++ and Fortran; computer program compilers; computer languages, and other closely related computer art.
2. Description of the Related Art
In the field of computing machines and computing performance, computer users have become accustomed to computer performance increasing steadily over the years as a result of technological innovation in the hardware of computers. However, there are limits on technology which tend to limit continued increases in computer hardware performance. For example, certain technical limitations tend to limit how fast a computer program can run on a single computer.
An alternative to increasing performance of a program on a single or small number of processing units is to spread the work to be done across multiple processors or multiple computers. Innovation and technical advancement in this area have provided for increasing computer program performance by developing techniques for spreading work across a plurality of computers or central processing units. A common term for this spreading of work is “parallelization”. There are many forms of parallelization and ways of achieving parallelization which are discussed at length in literature surrounding the art and which will not be discussed here. One particular area of research and significant development which is of particular interest in the field of parallelization is a standard for describing and enabling parallelization called OpenMP Architecture (Open Multi-Processing Architecture). “OpenMP” is a trademark of the OpenMP Architecture Review Board, and the standard is described on the Internet at a website“OpenMP.org” The OpenMP Architecture is described within this webpage as “API Specification for Parallel Programming”. Wikipedia.org further describes OpenMP as:                “The OpenMP (Open Multi-Processing) is an application programming interface (API) that supports multi platform shared memory multiprocessing programming in C, C++ and Fortran on many architectures, including Unix and Microsoft Windows platforms. It consists of a set of compiler directives, library routines, and environment variables that influence run-time behavior.        Jointly defined by a group of major computer hardware and software vendors, OpenMP is a portable, scalable model that gives programmers a simple and flexible interface for developing parallel applications for platforms ranging from the desktop to the supercomputer.        An application built with the hybrid model of parallel programming can run on a computer cluster using both OpenMP and Message Passing Interface (MPI), or more transparently through the use of OpenMP extensions for non-shared memory systems.”        
OpenMP as a project was initiated in 1997 at a major conference on High Performance Computing Networking, and Storage held in San Jose, Calif. The conference was named “Supercomputing 1997”. The proposal for a parallel programming “standard” grew out of a “birds of a feather” session to unveil new portable programming interfaces for shared memory parallel computers. Following the conference a company was set up to own and maintain the new informal standard and it was called the OpenMP Architectural Review Board (ARB).
The OpenMP architecture provides a methodology and programming language enhancements that enable processing with parallel threads of processing. OpenMP requires support within (or “by”) a compiler, that is, it is not just a library that is called; it requires support by the compiler itself. OpenMP today is supported by several major compilers (GNU C compiler, Intel, Microsoft) for computer programs written in the languages of C/C++, and Fortran. There are books and classes on parallel programming based upon OpenMP.
However, OpenMP architectural support for programs written in other computer languages such as Cobol, Pascal and other either “older” or less common computer programming languages is not provided by major computer program compiler manufacturers such as Intel, Microsoft, or by providers of open source compilers such as GNU.org. As a result, the benefits of programming utilizing OpenMP to achieve parallelism are not currently available for programs written in these older languages, and support is not likely to be provided in the future by major compiler manufacturers because most new program development is done in more modern languages.
However, Cobol is still the programming language for many large computer business applications that are in production use today, and the performance of these programs or applications is often critical to operation of a business. Therefore, it would be beneficial if these large computer applications could be made to benefit from parallel programming in order to improve their performance during execution. Improvement in performance of what are commonly called “batch” programs might be especially important. The term “Batch” is used to describe a job, often run at night, that typically processes a large amount of data from a day of recorded transactions. Oftentimes “batch” programs are run at night and oftentimes must be completed before more transaction data can be accumulated (the next day for example).
Providing support for parallelization techniques by a compiler for a language such as Cobol is a very significant task for several reasons. First of all, developing a new compiler or significantly enhancing an existing compiler for any purpose can be a large task. Second, providing for parallelization enabling concepts within generated code from a compiler is a difficult job, and would be a very significant development task. Third, one major component of “good” compilers is providing a facility/mechanism/capability for carrying out very extensive optimization of generated code in order to achieve good performance during execution, and support for OpenMP would typically have impact on those optimizations. For these reasons and others such as lack of limited resources, innovation, financial burdens etc., major compiler builders have not provided a Cobol compiler that supports parallelism such as the OpenMP architecture.
Because of the business nature of most Cobol applications, existing Cobol compilers used by large businesses are very carefully maintained by vendors in providing for backwards compatibility and to avoid any possible introduction of bugs or flaws in the code generation process. The importance of producing correct calculations is emphasized and thus, even the smallest changes are typically verified carefully by running large numbers of test programs. As a result, changes and improvements to Cobol compilers are made slowly and carefully, possibly even reluctantly.
Another reason parallelization support has not been provided for the Cobol programming language is that the language of Cobol is not necessarily well suited to parallelization. The Cobol language, because it is quite “old”, has typically been used to describe a program that exists statically in memory with static memory variables, and oftentimes without the use of “modern” programming constructs such as “stacks” or automatic memory allocation and de-allocation. This tends to create conflicts in the use of memory based variables when attempts are made to parallelize program execution, because parallelization typically requires at least some degree of isolation of memory between the units of parallelized code. Also, there are no OpenMP library facilities available which directly provide OpenMP support for the Cobol language.
But, improving the performance of programs written in Cobol is potentially important, and improving performance by providing for support of parallel processing in the execution of a Cobol program would result in a potentially significant increase in performance by enabling application and utilization of multiple processors or computing cores to a single program or problem which was normally run, in the prior art, as a single-thread process or procedure. The same is also true for other languages such as Pascal, PL/1, or other possibly “older” languages where no support for parallelism is currently provided by major compiler providers.
The state of the art has also evolved such that parallelization or multithreading of programs now has some increased potential for being automated, or at least done with more help by tools than in the past. One company that is exploring this area of research is a Swedish company called Nema Labs which is developing a tool called “FasThread”. Nema Labs has a website at: “NemaLabs.com”. From the company's website is the statement: “Nema Labs is a privately held company founded in 2006 with the mission to provide programmers with powerful and easy-to-use threading tools for multi-core platforms. The technology base originates on world-class research . . . ”
Nema Labs provides a tool which attempts to semi-automate the parallelization of programs written in “C” and is currently working on a version of the tool which also supports “C++”. The FasThread's analysis and processing tool includes a mechanism for inserting OpenMP pragmas into programs in the “C” language based upon analysis by the tool. This type of tool provides the potential of being useful in achieving parallelization. It utilizes OpenMP and is not applicable to a source program described in any language except its “native” input language of C.
A Cobol programmer may thus now be motivated to look at the potential for parallelization of certain, possibly large, Cobol programs, in spite of the possibility that parallelization of these programs may not have been feasible in the past.